/**
 * 计算工作线程入口文件
 * 用于执行密集型计算任务
 */

// 引入worker环境兼容性修复工具
const workerPolyfill = require('../utils/worker-polyfill');

// 在worker初始化时运行所有修复
workerPolyfill.runAllFixes();

// 处理来自主线程的消息
self.onMessage(function(message) {
  console.log('Worker收到消息:', message);
  
  try {
    // 根据消息类型执行不同的计算任务
    const { type, data } = message;
    
    let result = null;
    
    switch (type) {
      case 'compute_data':
        result = processComputeData(data);
        break;
      case 'filter_array':
        result = filterArray(data);
        break;
      case 'sort_complex':
        result = sortComplex(data);
        break;
      default:
        result = { error: 'Unknown operation type' };
    }
    
    // 将结果发送回主线程
    self.postMessage({
      type: `${type}_result`,
      result: result,
      success: true
    });
  } catch (e) {
    // 处理错误并发送回主线程
    console.error('Worker处理消息错误:', e);
    self.postMessage({
      type: 'error',
      error: e.message || String(e),
      success: false
    });
  }
});

/**
 * 处理计算数据
 */
function processComputeData(data) {
  // 执行复杂计算
  return {
    processed: true,
    value: data.value * 2
  };
}

/**
 * 数组过滤处理
 */
function filterArray(data) {
  if (!Array.isArray(data.array)) {
    throw new Error('Input is not an array');
  }
  
  // 根据条件过滤数组
  const filtered = data.array.filter(item => {
    return item > (data.threshold || 0);
  });
  
  return {
    original: data.array.length,
    filtered: filtered.length,
    result: filtered
  };
}

/**
 * 复杂排序
 */
function sortComplex(data) {
  if (!Array.isArray(data.items)) {
    throw new Error('Items must be an array');
  }
  
  // 复杂排序逻辑
  const sorted = [...data.items].sort((a, b) => {
    if (data.sortBy && typeof a === 'object' && typeof b === 'object') {
      return a[data.sortBy] - b[data.sortBy];
    }
    return a - b;
  });
  
  return {
    sorted: sorted,
    count: sorted.length
  };
} 